package com.tedu.api;

import org.junit.Test;

/**
 * java面向对象----不是真的面向对象---八大基本数据类型
 * 创建对象---类【属性gggggggggt kk，构造器，方法】
 * 8个包装类：针对八大基本数据类型提供对应类【方法基本上互通】
 * 包装类包位置：java.lang
 * 八大基本数据类型（不是面向对象）     针对八大基本数据类型对应包装类
 *   int                   Integer  继承Number父类【抽象】
 *   lang                   Lang      继承Number父类【抽象】
 *   double                 Double     继承Number父类【抽象】
 *   short                  Short        继承Number父类【抽象】
 *   float                  Float          继承Number父类【抽象】
 *   byte                   Byte            继承Number父类【抽象】
 *   char                   Char             继承Object父类
 *   boolean                Boolean           继承Object父类
 *
 */
public class PackingAPI {
    @Test
    public void test(){
        int a=1;//不是面向对象，通过，【反射】
        //创建int类型对象：Integer构造器：引入|直接写
        Integer i=new Integer(a);
        i.toString();
     }
    /**
     * 包装类API
     * xxxValue方法===静态方法valueOf（）    返回值：对应数据类型
     * 作用：把包装类转韩为基本数据类型的方法
     * 测试：6个包装类
     */
    @Test
    public void testxxxValue(){
        Integer i=new Integer(2);//打包：对应类放入包装类
        i.intValue(); //int类型和Integer
        System.out.println(i);
        //测试:其他7个包装类  10分钟
        //String s1="123.123";     Double
        //String s2=“1”；           Byte
        //String s3=“123.123F”；    Float
        //String s4=“1234L”；       Long
        //String s5=“true”；        Boolean
        //String s6=“a”；           Character
        String s1="123.123";
        Double d=new Double(s1);
        d.doubleValue();
        System.out.println(d);
        String s2="1";
        Byte b=new Byte(s2);
        b.byteValue();
        System.out.println(b);
        Float s3=new Float(123.123);
        s3=s3.floatValue();
        System.out.println(s3);
        Long s4=new Long(1234);
        s4=s4.longValue();
        System.out.println(s4);
        String s5="true";
        Boolean b1=new Boolean(s5);
        b1=b1.booleanValue();
        System.out.println(b1);
        char s6='a';
        Character c=new Character(s6);
        c.charValue();
        System.out.println(c);

    }
    /**
     * 包装类具备静态方法
     * valueOf（）   返回值：对应数据类型
     * 作用：把包装类转换为基本数据类型的方法
     */
    @Test
    public void testValueOf(){
        int i=Integer.valueOf(1);//打包拆包一体化
        boolean b=Boolean.valueOf(true);
        char c=Character.valueOf('1');
        Float.valueOf(1.23F); //1.123默认 double 编译工具
    }
    /**
     * 包装类--------------Servlet[JavaBean===实体类]
     * public class Person{
     *     Integer id; //成员变量 ---解析
     * }
     * parseXXX() 静态方法   返回值：对应类型
     * 作用：获取到的字符串转换为对应类型
     */
    @Test
    public void testParseXXX(){
        String s="123"; //将字符串传换为整数
        int i=Integer.parseInt(s); //区别：解析字符串，转换为正确类型
        int is=Integer.valueOf(s);//区别：存入值，打包拆包获取值
        System.out.println(i);
        //将整型转换为字符串
        String s1=String.valueOf(123);//与包装类，用法一致，实现不一致
        //自己测： String s2=“456f"；   char s3=’a‘；
        String s2="456f";
        float f=Float.parseFloat(s2);
        System.out.println(f);
        char s3='a';
        //Character 没有针对字符解析

    }
    /**
     * 自动拆装箱
     * JDK1.5之前没有自动拆装箱
     * JDK1.5之后自动拆装箱  2004
     */
    @Test
    public void testJ(){
        //JDK1.5之前没有自动拆装箱
        Integer in=Integer.valueOf(1); //装箱
        int ii=in.intValue();//拆箱
        //JDK1.5之后自动拆装箱
        Integer i=1;
        int is=i;
        //编译器帮我们写了拆装箱过程---JVM虚拟机认1.5之前写法
    }
}
